package com.javablog.elasticsearch.util;
 
import java.net.Inet4Address;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.time.LocalDate;
import java.time.ZoneId;
import java.util.Date;
import java.util.Enumeration;
import java.util.Random;

/**
 * @author tan
 * @date 2020-04
 * 
 * Twitter_Snowflake<br>
 * SnowFlake的结构如下(每部分用-分开):<br>
 * 0 - 0000000000 0000000000 0000000000 0000000000 0 - 00000 - 00000 - 000000000000 <br>
 * 1位标识，由于long基本类型在Java中是带符号的，最高位是符号位，正数是0，负数是1，所以id一般是正数，最高位是0<br>
 * 41位时间截(毫秒级)，注意，41位时间截不是存储当前时间的时间截，而是存储时间截的差值（当前时间截 - 开始时间截)
 * 得到的值），这里的的开始时间截，一般是我们的id生成器开始使用的时间，由我们程序来指定的（如下下面程序IdWorker类的startTime属性）。41位的时间截，可以使用69年，年T = (1L << 41) / (1000L * 60 * 60 * 24 * 365) = 69<br>
 * 10位的数据机器位，可以部署在1024个节点，包括5位datacenterId和5位workerId<br>
 * 12位序列，毫秒内的计数，12位的计数顺序号支持每个节点每毫秒(同一机器，同一时间截)产生4096个ID序号<br>
 * 加起来刚好64位，为一个Long型。<br>
 * SnowFlake的优点是，整体上按照时间自增排序，并且整个分布式系统内不会产生ID碰撞(由数据中心ID和机器ID作区分)，并且效率较高，经测试，SnowFlake每秒能够产生26万ID左右。
 */
public class SnowflakeIdUtil {
 
    // ==============================Fields===========================================
    /** 开始时间截 (2019-01-01) */
    private final long twepoch =
                                 1617811200000L;
 
    /** 机器id所占的位数 */
    private final long workerIdBits = 5L;
 
    /** 数据标识id所占的位数 */
    private final long datacenterIdBits = 5L;
 
    /** 支持的最大机器id，结果是31 (这个移位算法可以很快的计算出几位二进制数所能表示的最大十进制数) */
    private final long maxWorkerId = -1L ^ (-1L << workerIdBits);
 
    /** 支持的最大数据标识id，结果是31 */
    private final long maxDatacenterId = -1L ^ (-1L << datacenterIdBits);
 
    /** 序列在id中占的位数 */
    private final long sequenceBits = 12L;
 
    /** 机器ID向左移12位 */
    private final long workerIdShift = sequenceBits;
 
    /** 数据标识id向左移17位(12+5) */
    private final long datacenterIdShift = sequenceBits + workerIdBits;
 
    /** 时间截向左移22位(5+5+12) */
    private final long timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits;
 
    /** 生成序列的掩码，这里为4095 (0b111111111111=0xfff=4095) */
    private final long sequenceMask = -1L ^ (-1L << sequenceBits);
 
    /** 工作机器ID(0~31) */
    private long workerId;
 
    /** 数据中心ID(0~31) */
    private long datacenterId;
 
    /** 毫秒内序列(0~4095) */
    private long sequence = 0L;
 
    /** 上次生成ID的时间截 */
    private long lastTimestamp = -1L;
    
    /** 默认实现，工作ID用本机ip生成，数据中心ID 用随机数 */
    private static SnowflakeIdUtil snowflakeIdUtil;
 
    //==============================Constructors=====================================
    /**
     * 构造函数
     * @param workerId 工作ID (0~31)
     * @param datacenterId 数据中心ID (0~31)
     */
    public SnowflakeIdUtil(long workerId, long datacenterId) {
        if (workerId > maxWorkerId || workerId < 0) {
            throw new IllegalArgumentException(String.format("worker Id can't be greater than %d or less than 0", maxWorkerId));
        }
        if (datacenterId > maxDatacenterId || datacenterId < 0) {
            throw new IllegalArgumentException(String.format("datacenter Id can't be greater than %d or less than 0", maxDatacenterId));
        }
        this.workerId = workerId;
        this.datacenterId = datacenterId;
    }
 
    // ==============================Methods==========================================
    /**
     * 获得下一个ID (该方法是线程安全的)
     * @return SnowflakeId
     */
    public synchronized long nextId() {
        long timestamp = timeGen();
 
        //如果当前时间小于上一次ID生成的时间戳，说明系统时钟回退过这个时候应当抛出异常
        if (timestamp < lastTimestamp) {
            throw new RuntimeException(
                    String.format("Clock moved backwards.  Refusing to generate id for %d milliseconds", lastTimestamp - timestamp));
        }
 
        //如果是同一时间生成的，则进行毫秒内序列
        if (lastTimestamp == timestamp) {
            sequence = (sequence + 1) & sequenceMask;
            //毫秒内序列溢出
            if (sequence == 0) {
                //阻塞到下一个毫秒,获得新的时间戳
                timestamp = tilNextMillis(lastTimestamp);
            }
        }
        //时间戳改变，毫秒内序列重置
        else {
        	    //sequence = 0L; 
            sequence = timestamp & 1L; //根据当前时间戳单or双数重置序列，（修正在大多数情况下生成偶数的情况）
        }
 
        //上次生成ID的时间截
        lastTimestamp = timestamp;
 
        //移位并通过或运算拼到一起组成64位的ID
        return ((timestamp - twepoch) << timestampLeftShift) //
                | (datacenterId << datacenterIdShift) //
                | (workerId << workerIdShift) //
                | sequence;
    }
 
    /**
     * 阻塞到下一个毫秒，直到获得新的时间戳
     * @param lastTimestamp 上次生成ID的时间截
     * @return 当前时间戳
     */
    protected long tilNextMillis(long lastTimestamp) {
        long timestamp = timeGen();
        while (timestamp <= lastTimestamp) {
            timestamp = timeGen();
        }
        return timestamp;
    }
 
    /**
     * 返回以毫秒为单位的当前时间
     * @return 当前时间(毫秒)
     */
    protected long timeGen() {
        return System.currentTimeMillis();
    }
 
    /**
     * 获取本机ip
     * @return
     */
    private static String getHostIp(){
        try{
            Enumeration<NetworkInterface> allNetInterfaces = NetworkInterface.getNetworkInterfaces();
            while (allNetInterfaces.hasMoreElements()){
                NetworkInterface netInterface = (NetworkInterface) allNetInterfaces.nextElement();
                Enumeration<InetAddress> addresses = netInterface.getInetAddresses();
                while (addresses.hasMoreElements()){
                    InetAddress ip = (InetAddress) addresses.nextElement();
                    if (ip != null 
                            && ip instanceof Inet4Address
                            && !ip.isLoopbackAddress() //loopback地址即本机地址，IPv4的loopback范围是127.0.0.0 ~ 127.255.255.255
                            && ip.getHostAddress().indexOf(":")==-1){
                        System.out.println("本机的IP = " + ip.getHostAddress());
                        return ip.getHostAddress();
                    } 
                }
            }
        }catch(Exception e){
            e.printStackTrace();
        }
        return null;
    }
    
    
    /*默认实现 逻辑：
    工作id -> 用服务器ip生成，ip转化为long再模32（如有集群部署，且机器ip是连续的,
    如我的集群服务器是192.168.180.54~58共五台机器，这样取模就能避免重复.如服务器ip不连续，慎用，慎用，慎用！！！！！！ 重要事情说三遍）
    数据中心ID -> 取0～31的随机数*/
    static {
    	 Random rd = new Random();
    	 long workerId = rd.nextInt(31), datacenterId = rd.nextInt(31); //工作id，数据中心ID
    	 
    	 //获取当前ip,生成工作id
    	 String ip = getHostIp();
    	 if(ip != null) {
    		 workerId = Long.parseLong(ip.replaceAll("\\.", ""));
    		 workerId = workerId % 32; //因为占用5位，模32
    	 }
    	 snowflakeIdUtil = new SnowflakeIdUtil(workerId, datacenterId);
    }
 
    //默认实现
    public static long newId() {
    		return snowflakeIdUtil.nextId();
    }
    
    //==============================Test=============================================
    /** 测试 
     * @throws InterruptedException */
    public static void main(String[] args) throws InterruptedException {


        LocalDate of = LocalDate.of(2021, 4, 8);
        ZoneId zoneId3 = ZoneId.systemDefault();
        System.out.println("LocalDate转时间戳:" + of.atStartOfDay(zoneId3).toInstant().toEpochMilli());

        //默认实现
        long start=new Date().getTime();
	    	for (int i = 0; i < 100; i++) {
	            long id = SnowflakeIdUtil.newId();
	            //分4个库,每个库8张表 总共32张表
                long l = id % 2;
                long l1 = (id >> 1) % 4;
//	            Thread.sleep(10);
	            System.out.println("在"+l+"库中"+","+l1+"表中");
	        }
        System.out.println(new Date().getTime()-start);
    	
    	
    	    //自定义实现 
    	    // 需要传入 workerId工作id 与 datacenterId 数据中心id  请自行实现这里默认取0
//        SnowflakeIdUtil util2 = new SnowflakeIdUtil(0, 0);
//        for (int i = 0; i < 100; i++) {
//            long id = util2.nextId();
//            //Thread.sleep(10);
//             System.out.println("生成第"+i+"id："+id);
//        }
        
    }
}